{ ***  cef_command_line_capi.h  *** }


    PCefCommandLine	= ^TCefCommandLine;

    // Structure used to create and/or parse command line arguments. Arguments with
    // '--', '-' and, on Windows, '/' prefixes are considered switches. Switches
    // will always precede any arguments without switch prefixes. Switches can
    // optionally have a value specified using the '=' delimiter (e.g.
    // "-switch=value"). An argument of "--" will terminate switch parsing with all
    // subsequent tokens, regardless of prefix, being interpreted as non-switch
    // arguments. Switch names are considered case-insensitive. This structure can
    // be used before cef_initialize() is called.
    TCefCommandLine = record
        // Base structure.
        base: TCefBase;

        // Returns true (1) if this object is valid. Do not call any other functions
        // if this function returns false (0).
        is_valid: function(self: PCefCommandLine): Integer; cconv;

        // Returns true (1) if the values of this object are read-only. Some APIs may
        // expose read-only objects.
        is_read_only: function(self: PCefCommandLine): Integer; cconv;

        // Returns a writable copy of this object.
        copy: function(self: PCefCommandLine): PCefCommandLine; cconv;

        // Initialize the command line with the specified |argc| and |argv| values.
        // The first argument must be the name of the program. This function is only
        // supported on non-Windows platforms.
        init_from_argv: procedure(self: PCefCommandLine; argc: Integer; const argv: PPAnsiChar); cconv;

        // Initialize the command line with the string returned by calling
        // GetCommandLineW(). This function is only supported on Windows.
        init_from_string: procedure(self: PCefCommandLine; command_line: PCefString); cconv;

        // Reset the command-line switches and arguments but leave the program
        // component unchanged.
        reset: procedure(self: PCefCommandLine); cconv;

        // Retrieve the original command line string as a vector of strings. The argv
        // array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
        get_argv: procedure(self: PCefCommandLine; argv: TCefStringList); cconv;

        // Constructs and returns the represented command line string. Use this
        // function cautiously because quoting behavior is unclear.
        //
        // The resulting string must be freed by calling cef_string_userfree_free().
        get_command_line_string: function(self: PCefCommandLine): PCefStringUserFree; cconv;

        // Get the program part of the command line string (the first item).
        //
        // The resulting string must be freed by calling cef_string_userfree_free().
        get_program: function(self: PCefCommandLine): PCefStringUserFree; cconv;

        // Set the program part of the command line string (the first item).
        set_program: procedure(self: PCefCommandLine; const program_: PCefString); cconv;

        // Returns true (1) if the command line has switches.
        has_switches: function(self: PCefCommandLine): Integer; cconv;

        // Returns true (1) if the command line contains the given switch.
        has_switch: function(self: PCefCommandLine; const name: PCefString): Integer; cconv;

        // Returns the value associated with the given switch. If the switch has no
        // value or isn't present this function returns the NULL string.
        //
        // The resulting string must be freed by calling cef_string_userfree_free().
        get_switch_value: function(self: PCefCommandLine; const name: PCefString): PCefStringUserFree; cconv;

        // Returns the map of switch names and values. If a switch has no value an
        // NULL string is returned.
        get_switches: procedure(self: PCefCommandLine; switches: TCefStringMap); cconv;

        // Add a switch to the end of the command line. If the switch has no value
        // pass an NULL value string.
        append_switch: procedure(self: PCefCommandLine; const name: PCefString); cconv;

        // Add a switch with the specified value to the end of the command line.
        append_switch_with_value: procedure(self: PCefCommandLine; const name, value: PCefString); cconv;

        // True if there are remaining command line arguments.
        has_arguments: function(self: PCefCommandLine): Integer; cconv;

        // Get the remaining command line arguments.
        get_arguments: procedure(self: PCefCommandLine; arguments: TCefStringList); cconv;

        // Add an argument to the end of the command line.
        append_argument: procedure(self: PCefCommandLine; const argument: PCefString); cconv;

        // Insert a command before the current command. Common for debuggers, like
        // "valgrind" or "gdb --args".
        prepend_wrapper: procedure(self: PCefCommandLine; const wrapper: PCefString); cconv;
    end;

    // Create a new cef_command_line_t instance.
    tfn_cef_command_line_create = function: PCefCommandLine; cdecl;

    // Returns the singleton global cef_command_line_t object. The returned object
    // will be read-only.
    tfn_cef_command_line_get_global = function: PCefCommandLine; cdecl;

